package function;

import java.io.File;
import java.util.ArrayList;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import javax.xml.xpath.XPath;
import javax.xml.xpath.XPathConstants;
import javax.xml.xpath.XPathExpressionException;
import javax.xml.xpath.XPathFactory;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

public class Scenic {
	private String id;//景点id
	private String name;
	private String introduction;//景点简介
	private String popularity;//受欢迎度
	private int pathNumber;//通过此景点的岔路数
	//保存景点信息的xml文件路径
	static String xmlPath = "scenic.xml";

	public Scenic(String id, String name, String introduction, String popularity) {
		this.id = id;
		this.name = name;
		this.introduction = introduction;
		this.popularity=popularity;
	}
	
	public Scenic(String id, String name, String introduction) {
		this.id = id;
		this.name = name;
		this.introduction = introduction;
	}

	public Scenic() {
		this.id = null;
		this.name = null;
		this.introduction = null;
		this.pathNumber = 0;
	}

	public String getId() {
		return id;
	}

	public void setId(String id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getIntroduction() {
		return introduction;
	}

	public void setIntroduction(String introduction) {
		this.introduction = introduction;
	}

	public String getPopularity() {
		return popularity;
	}

	public void setPopularity(String popularity) {
		this.popularity = popularity;
	}

	public int getPathNumber() {
		return pathNumber;
	}

	public void setPathNumber(int pathNumber) {
		this.pathNumber = pathNumber;
	}


	//在排序时通过数组下标返回此景点的name
	public String findNameByNumber(int num) {
		return this.find(Integer.toString(num + 1)).getName();
	}
	//通过景点名称返回此景点在数组p中初始状态的下标
	public int findNumberByName(String name) {
		String s = findScenicByName(name);
		return Integer.parseInt(s) - 1;
	}
    //getAllScenics的public形式
	public ArrayList<String> display() {
		ArrayList<String> g = getAllScenics();
		return g;
	}
	//管理员添加景点
	public boolean add() {
		boolean a = addScenic(this);
		return a;
	}
	//管理员删除景点
	public boolean delete(String text) {
		boolean d = deleteScenic(text);
		return d;
	}
	//修改景点信息，
	public boolean modify(String text) {
		boolean m = modifyScenic(text, this);
		return m;
	}
	//通过传入的text（text中有该景点的id和name）返回对应景点对象，text对应gui界面中按钮组后显示的内容
	public Scenic find(String text) {
		Scenic n = findScenic(this, text);
		return n;
	}
	//查询景点，text对应gui界面中按钮组后显示的内容
	public String inquire(String text) {
		String i = inquireScenic(text);
		return i;
	}
	//模糊查询，text对应gui界面中按钮组后显示的内容
	public String fuzzyQuery(String text) {
		String f = fuzzyQueryScenics(text);
		return f;
	}
	//通过景点的受欢迎度排序
	public String sortByPopularity(String order) {
		String p = popularitySort(order);
		return p;
	}
	//通过此景点的岔路数排序
	public String sortByPathNumber(String order) {
		String pn = pathNumberSort(order);
		return pn;
	}

	/*getAllScenics()方法从xml文件中获取所有景点的ID和名称并放入list中，返回list
	 *  用于在界面中显示，界面中按钮后显示的就是此景点的id和名称
	 */
	private ArrayList<String> getAllScenics() {
		ArrayList<String> list = new ArrayList<String>();
		// 创建文件工厂实例，获取DOM解析器工厂
		DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
		// 如果创建的解析器在解析XML文档时必须删除元素内容中的空格，则为true，否则为false
		dbf.setIgnoringElementContentWhitespace(true);

		try {
			// 创建文件对象
			DocumentBuilder db = dbf.newDocumentBuilder();// 创建解析器，解析XML文档
			Document doc = db.parse(xmlPath); // 使用dom解析xml文件
			// 遍历列表，进行XML文件的数据提取
			// 根据标签名称来获取所有相关的节点放入sonlist中
			NodeList sonlist = doc.getElementsByTagName("scenic");
			for (int i = 0; i < sonlist.getLength(); i++) // 循环处理对象
			{
				// 节点属性的处理
				Element son = (Element) sonlist.item(i);
				// 根据标签名称来获取相关的节点
				NodeList elements1 = son.getElementsByTagName("id");
				NodeList elements2 = son.getElementsByTagName("name");
				Node node1 = elements1.item(0);
				Node node2 = elements2.item(0);
//				判断该子节点是否为元素节点，若是，获取节点内容
				if (node1.getNodeType() == Node.ELEMENT_NODE && node2.getNodeType() == Node.ELEMENT_NODE) {
					//value1的值为景点id
					String value1 = node1.getFirstChild().getNodeValue();
					//value2的值为景点name
					String value2 = node2.getFirstChild().getNodeValue();
					list.add(value1 + "  " + value2);
				}
			}
		} catch (Exception e) {
			System.out.println(e.getMessage());
		}
		return list;
		
	}
	//用于实现管理员添加景点的方法，在ManagerScenic类的“添加”按钮处被调用
	private boolean addScenic(Scenic scenic) {
		// 创建文件工厂实例，用于解析xml文件
		DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
		dbf.setIgnoringElementContentWhitespace(false);

		try {
			//获取DOM解析器
			DocumentBuilder db = dbf.newDocumentBuilder();
			//用DOM解析器解析xml并生成DOM树
			Document xmldoc = db.parse(xmlPath);

			// 根据节点名称来获取所有相关的节点（获取元素列表）
			NodeList sonlist = xmldoc.getElementsByTagName("scenic");
			for (int i = 0; i < sonlist.getLength(); i++) // 循环处理对象
			{
				// 节点属性的处理
				Element son = (Element) sonlist.item(i);
				NodeList elements;
				//在xml文件中通过标签名查找element
				elements = son.getElementsByTagName("id");
				Node node0 = elements.item(0);

				if (node0.getNodeType() == Node.ELEMENT_NODE) {
					//value0为景点id
					String value0 = node0.getFirstChild().getNodeValue();
					//新添加的景点的id不能和已有景点的id相等
					if (value0.equals(scenic.getId())) {
						return false;
					}
				}
			}

			// 获取根节点
			Element root = xmldoc.getDocumentElement();
			// 创建节点son，用于临时表示新添加的scenic对象
			Element son = xmldoc.createElement("scenic");

			Element id = xmldoc.createElement("id");
			id.setTextContent(scenic.getId());
			/*xml的树形结构，id元素是scenic元素的儿子,
			 * 即在son之下创建子节点，将新添加的scenic对象的属性
			 * 创建为scenic对象的子节点加入进来
			 */
			son.appendChild(id);

			Element name = xmldoc.createElement("name");
			name.setTextContent(scenic.getName());
			son.appendChild(name);

			Element introduction = xmldoc.createElement("introduction");
			introduction.setTextContent(scenic.getIntroduction());
			son.appendChild(introduction);
			
			Element popularity = xmldoc.createElement("popularity");
			popularity.setTextContent(scenic.getPopularity());
			son.appendChild(popularity);

			// 把新添加的scenic添加到根节点的子节点中
			root.appendChild(son);

			// 保存到xml文件中
			TransformerFactory factory = TransformerFactory.newInstance();
			Transformer former = factory.newTransformer();
			former.setOutputProperty(OutputKeys.VERSION, "1.0");
			former.setOutputProperty(OutputKeys.INDENT, "yes");// 缩进
			former.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
			former.transform(new DOMSource(xmldoc), new StreamResult(new File(xmlPath)));

		} catch (Exception e) {
			System.out.println(e.getMessage());
		}
		return true;
	}
/*传入的参数text的格式为：id+"  "+name，
 * 注意此处text的内容对应gui界面按钮后显示的内容，看界面即可明白
 * 当用户点击按钮即可将按钮后的内容作为text传入此函数
 * 可参见ManagerScenic类的删除按钮处一起理解
 */
	private boolean deleteScenic(String text) {
		String a[] = text.split("  ");
		String id = a[0];
		// 创建文件工厂实例
		DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
		// 如果创建的解析器在解析XML文档时必须删除元素内容中的空格，则为true，否则为false
		dbf.setIgnoringElementContentWhitespace(true);

		try {
			// 创建解析器，解析XML文档
			DocumentBuilder db = dbf.newDocumentBuilder();
			// 使用dom解析xml文件
			Document xmldoc = db.parse(xmlPath);
			// 获取根节点
			Element root = xmldoc.getDocumentElement();
			Element son = (Element) selectSingleNode("/scenicList/scenic/id[text()='" + id + "']/parent::*", root);

			// 删除该节点
			root.removeChild(son);
			// 保存删除后的结果
			TransformerFactory factory = TransformerFactory.newInstance();
			Transformer former = factory.newTransformer();
			former.setOutputProperty(OutputKeys.VERSION, "1.0");
			former.setOutputProperty(OutputKeys.INDENT, "yes");// 缩进
			former.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
			former.transform(new DOMSource(xmldoc), new StreamResult(new File(xmlPath)));
			return true;
		} catch (Exception e) {
			System.out.println(e.getMessage());
			return false;
		}
	}
	//查询景点，传入的参数text为景点id和景点名称，中间以两个空格分隔
	private String inquireScenic(String text) {
		String a[] = text.split("  ");
		String id = a[0];
		// 创建文件工厂实例
		DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
		// 如果创建的解析器在解析XML文档时必须删除元素内容中的空格，则为true，否则为false
		dbf.setIgnoringElementContentWhitespace(true);

		String information = "<html><body>";
		try {
			// 创建解析器，解析XML文档
			DocumentBuilder db = dbf.newDocumentBuilder();
			Document doc = db.parse(xmlPath); // 使用dom解析xml文件

			// 根据节点名称来获取所有相关的节点
			NodeList sonlist = doc.getElementsByTagName("scenic");
			for (int i = 0; i < sonlist.getLength(); i++) // 循环处理对象
			{
				// 节点属性的处理
				Element son = (Element) sonlist.item(i);
				NodeList elements;
				//在xml文件中通过标签名查找element
				elements = son.getElementsByTagName("id");
				Node node0 = elements.item(0);

				if (node0.getNodeType() == Node.ELEMENT_NODE) {
					String value0 = node0.getFirstChild().getNodeValue();
					if (value0.equals(id)) {
						for (Node node = son.getFirstChild(); node != null; node = node.getNextSibling()) {
							// 判断是否为元素节点
							if (node.getNodeType() == Node.ELEMENT_NODE) {
								String name = node.getNodeName();
								String value = node.getFirstChild().getNodeValue();
								information += (name + ":" + value + "<br/>");
							}
						}
					}
				}
			}
		} catch (Exception e) {
			System.out.println(e.getMessage());
		}
		information += "</body></html>";
		//构建的information用于在gui界面显示，看界面即可明白
		return information;
	}
	//通过景点名查找景点，若不存在此景点名，返回null，若存在则返回此景点的id
	private String findScenicByName(String name) {
		DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
		dbf.setIgnoringElementContentWhitespace(true);

		try {
			DocumentBuilder db = dbf.newDocumentBuilder();
			Document xmldoc = db.parse(xmlPath);
			// 获取根节点
			Element root = xmldoc.getDocumentElement();
			//构建str用于查询满足特定条件的结点
			String str = "/scenicList/scenic/name[text()='" + name + "']/parent::*";
			//将str作为参数传入selectSingleNode方法查找满足条件的结点
			Element son = (Element) selectSingleNode(str, root);

			for (Node node = son.getFirstChild(); node != null; node = node.getNextSibling()) {
				// 判断是否为元素节点
				if (node.getNodeType() == Node.ELEMENT_NODE) {
					String name0 = node.getNodeName();
					String value = node.getFirstChild().getNodeValue();
					if ("id".equals(name0)) {
						return value;//找到则返回此景点的id
					}
				}
			}
		} catch (Exception e) {
			System.out.println(e.getMessage());
		}
		return null;
	}
	/*
	 * 在ManagerScenic类中实现管理员修改景点信息的“修改”按钮处调用了此方法
	 * 通过结合界面即可理解此方法
	 * 通过传入用户选择的景点（JRadioButton）打印出此景点的信息
	 * 修改景点信息时，用户首先点击“修改”按钮，系统会将要修改景点的信息打印在界面上，
	 * 用户根据打印出的原有信息进行修改，修改完毕后点击“保存修改”按钮
	 * 即可将修改结果保存到xml文件中
	 */
	private Scenic findScenic(Scenic scenic, String text) {
		String a[] = text.split("  ");
		String id = a[0];

		DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
		dbf.setIgnoringElementContentWhitespace(true);

		try {
			DocumentBuilder db = dbf.newDocumentBuilder();
			Document xmldoc = db.parse(xmlPath);
			// 获取根节点
			Element root = xmldoc.getDocumentElement();
			//构建str用于查询满足特定条件的结点
			String str = "/scenicList/scenic/id[text()='" + id + "']/parent::*";
			//将str作为参数传入selectSingleNode方法查找满足条件的结点
			Element son = (Element) selectSingleNode(str, root);

			for (Node node = son.getFirstChild(); node != null; node = node.getNextSibling()) {
				// 判断是否为元素节点
				if (node.getNodeType() == Node.ELEMENT_NODE) {
					String name0 = node.getNodeName();
					String value = node.getFirstChild().getNodeValue();
					if ("id".equals(name0)) {
						scenic.setId(value);
					} else if ("name".equals(name0)) {
						scenic.setName(value);
					} else if ("introduction".equals(name0)) {
						scenic.setIntroduction(value);
					} else {
						scenic.setPopularity(value);
					}
				}
			}
		} catch (Exception e) {
			System.out.println(e.getMessage());
		}
		return scenic;
	}
		/*在ManagerScenic类中实现管理员修改景点信息的“保存修改”按钮处调用了此方法
		 * 通过结合界面即可理解此方法
		 * 修改景点信息时，用户首先点击“修改”按钮，系统会将要修改景点的信息打印在界面上
		 * 用户根据打印出的原有信息进行修改，修改完毕后点击“保存修改”按钮
		 * 即可将修改结果保存到xml文件中
		 */
	private boolean modifyScenic(String text, Scenic scenic) {
		String a[] = text.split("  ");
		String id = a[0];

		// 创建文件工厂实例
		DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
		dbf.setIgnoringElementContentWhitespace(true);

		try {
			// 从XML文档中获取DOM文档实例
			DocumentBuilder db = dbf.newDocumentBuilder();
			// 获取Document对象
			Document xmldoc = db.parse(xmlPath);

			// 获取根节点
			Element root = xmldoc.getDocumentElement();
			//构建str用于查询满足特定条件的结点
			String str = "/scenicList/scenic/id[text()='" + id + "']/parent::*";
			//将str作为参数传入selectSingleNode方法查找满足条件的结点
			Element per = (Element) selectSingleNode(str, root);

			per.getElementsByTagName("id").item(0).setTextContent(scenic.getId());
			per.getElementsByTagName("name").item(0).setTextContent(scenic.getName());
			per.getElementsByTagName("introduction").item(0).setTextContent(scenic.getIntroduction());
			per.getElementsByTagName("popularity").item(0).setTextContent(scenic.getPopularity());
			// 保存
			TransformerFactory factory = TransformerFactory.newInstance();
			Transformer former = factory.newTransformer();
			former.setOutputProperty(OutputKeys.VERSION, "1.0");
			former.setOutputProperty(OutputKeys.INDENT, "yes");// 缩进
			former.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
			former.transform(new DOMSource(xmldoc), new StreamResult(new File(xmlPath)));
			return true;
		} catch (Exception e) {
			System.out.println(e.getMessage());
			return false;
		}
	}
	/*
	 * 由于文本文件均采用xml格式，selectSingleNode方法在对四个xml文件进行操作的类
	 * Manager类，Notice类，Edge类，Scenic类中均有
	 * 此方法用于查询结点（xml为树型结构），且此方法只返回单个结点
	 */
	private static Node selectSingleNode(String express, Element source) {
		// 创建XPath工厂
		XPathFactory xpathFactory = XPathFactory.newInstance();
		// 创建XPath对象
		XPath xpath = xpathFactory.newXPath();

		Node result = null;
		try {
			//计算XPath表达式
			result = (Node) xpath.evaluate(express, source, XPathConstants.NODE);
		} catch (XPathExpressionException e) {
			System.out.println(e.getMessage());
		}
		//返回目标结点
		return result;
	}
	/*模糊查询景点，根据关键字查询（关键字可以在景点名称或景点介绍中），
	 * 通过判断是否为子串来实现查找成功则返回景点的相关简介，
	此方法在ScenicsFindAndSort类的"查询"按钮处被调用
	*/
	private static String fuzzyQueryScenics(String text) {
		DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
		// 如果创建的解析器在解析XML文档时必须删除元素内容中的空格，则为true，否则为false
		dbf.setIgnoringElementContentWhitespace(true);

		String information = "<html><body>";
		try {
			DocumentBuilder db = dbf.newDocumentBuilder();// 创建解析器，解析XML文档
			Document doc = db.parse(xmlPath); // 使用dom解析xml文件

			// 根据节点名称来获取所有相关的节点
			NodeList sonlist = doc.getElementsByTagName("scenic");
			for (int i = 0; i < sonlist.getLength(); i++) // 循环处理对象
			{
				// 节点属性的处理
				Element son = (Element) sonlist.item(i);
				NodeList elements1, elements2;
				elements1 = son.getElementsByTagName("name");
				elements2 = son.getElementsByTagName("introduction");
				Node node1 = elements1.item(0);
				Node node2 = elements2.item(0);

				if (node1.getNodeType() == Node.ELEMENT_NODE && node2.getNodeType() == Node.ELEMENT_NODE) {
					String value1 = node1.getFirstChild().getNodeValue();
					String value2 = node2.getFirstChild().getNodeValue();
					if (value1.indexOf(text) != -1 || value2.indexOf(text) != -1) {
						for (Node node = son.getFirstChild(); node != null; node = node.getNextSibling()) {
							// 判断是否为元素节点
							if (node.getNodeType() == Node.ELEMENT_NODE) {
								String name = node.getNodeName();
								String value = node.getFirstChild().getNodeValue();
								information += (name + ":" + value + "<br/>");
							}
						}
						information += "---------------------------<br/>";
					}
				}
			}
		} catch (Exception e) {
			System.out.println(e.getMessage());
		}
		information += "</body></html>";
		System.out.println(information);
		//构建的information用于在gui界面显示，看界面即可明白
		return information;
	}
		//根据景点的受欢迎程度对景点排序
	private static String popularitySort(String order) {
		Scenic[] p = new Scenic[12];
		for (int i = 0; i < p.length; i++) {
			p[i] = new Scenic();
		}
		String information = "<html><body>";
  
		// 创建文件工厂实例
		DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
		// 如果创建的解析器在解析XML文档时必须删除元素内容中的空格，则为true，否则为false
		dbf.setIgnoringElementContentWhitespace(true);
		
		try {
			// 创建文件对象
			DocumentBuilder db = dbf.newDocumentBuilder();// 创建解析器，解析XML文档
			Document doc = db.parse(xmlPath); // 使用dom解析xml文件
			// 遍历列表，进行XML文件的数据提取
			NodeList sonlist = doc.getElementsByTagName("scenic");//返回标签名为spot的一个元素列表
			for (int i = 0; i < sonlist.getLength(); i++) // 循环处理对象
			{
				// 节点属性的处理
				Element son = (Element) sonlist.item(i);
				NodeList elements1 = son.getElementsByTagName("name");
				NodeList elements2 = son.getElementsByTagName("popularity");
				Node node1 = elements1.item(0);
				Node node2 = elements2.item(0);

				if (node1.getNodeType() == Node.ELEMENT_NODE && node2.getNodeType() == Node.ELEMENT_NODE) {
					String value1 = node1.getFirstChild().getNodeValue();
					String value2 = node2.getFirstChild().getNodeValue();
					p[i].setName(value1);
					p[i].setPopularity(value2);
				}
			}
		} catch (Exception e) {
			System.out.println(e.getMessage());
		}
		popularityQuickSort(p,0,p.length-1);

		if (order.equals("升序")) {
			for (int i = 0; i < 12; i++) {
				information += ("name:" + p[i].getName() + "  " + "popularity:" + p[i].getPopularity() + "<br/>");
			}
		} else {
			for (int i = 11; i >= 0; i--) {
				information += ("name:" + p[i].getName() + "  " + "popularity:" + p[i].getPopularity() + "<br/>");
			}
		}
		information += "</body></html>";
		System.out.println(information);
		//构建的information用于在gui界面显示，看界面即可明白
		return information;
	}
	//根据景点受欢迎度对景点进行快速排序
	static void popularityQuickSort(Scenic p[],int l,int r) {
		if(l<r){
			int i = l;
			int	j = r;
			Scenic temp = p[l];
			int x=Integer.parseInt(p[l].getPopularity());
			while(i<j) {
				//从右向左找第一个popularity值小于x的
				while(i<j && Integer.parseInt(p[j].getPopularity())>=x)
					j--;
				if(i<j)
					p[i++] = p[j];
				//从左向右找第一个popularity值大于x的
				while(i<j && Integer.parseInt(p[i].getPopularity())<x)
					i++;
				if(i<j)
					p[j--]=p[i];
			}
			p[i] = temp;
			popularityQuickSort(p, l, i - 1); // 递归调用 
			popularityQuickSort(p, i + 1, r);
	
		}
		}
	//根据景点的岔路数排序
	private String pathNumberSort(String order) {
		Scenic[] p = new Scenic[12];
		for (int i = 0; i < p.length; i++) {
			p[i] = new Scenic();
		}
		String information = "<html><body>";
		AdjacencyMatrix am = new AdjacencyMatrix(12);
		am.create();
		//从邻接矩阵中获取景点的岔路数
		for (int i = 0; i < p.length; i++) {
			p[i].setName(findNameByNumber(i));
			for (int j = 0; j < p.length; j++) {
				if (am.get(i, j) > 0 && am.get(i, j) < 32767) {
					p[i].pathNumber++;
				}
			}
		}
		pathNumberQuickSort(p,0,p.length-1);

		if (order.equals("升序")) {
			for (int i = 0; i < 12; i++) {
				information += ("name:" + p[i].getName() + "  " + "path number:" + p[i].getPathNumber() + "<br/>");
			}
		} else {
			for (int i = 11; i >= 0; i--) {
				information += ("name:" + p[i].getName() + "  " + "path number:" + p[i].getPathNumber() + "<br/>");
			}
		}
		information += "</body></html>";
		//构建的information用于在gui界面显示，看界面即可明白
		return information;
	}
	//根据景点岔路数对景点进行快速排序
		static void pathNumberQuickSort(Scenic p[],int l,int r) {
			if(l<r){
				int i = l;
				int	j = r;
				Scenic temp = p[l];
				int x=p[l].getPathNumber();
				while(i<j) {
					//从右向左找第一个popularity值小于x的
					while(i<j && p[j].getPathNumber()>=x)
						j--;
					if(i<j)
						p[i++] = p[j];
					//从左向右找第一个popularity值大于x的
					while(i<j && p[i].getPathNumber()<x)
						i++;
					if(i<j)
						p[j--]=p[i];
				}
				p[i] = temp;
				pathNumberQuickSort(p, l, i - 1); // 递归调用 
				pathNumberQuickSort(p, i + 1, r);
		
			}
			}
		//获取景点总个数，将景点总个数存放在变量i中并返回
	public int getTotalNumber() {
		int i = 0;
		// 创建文件工厂实例，获取DOM解析器工厂
		DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
		// 如果创建的解析器在解析XML文档时必须删除元素内容中的空格，则为true，否则为false
		dbf.setIgnoringElementContentWhitespace(true);
		try {
			// 创建文件对象
			DocumentBuilder db = dbf.newDocumentBuilder();// 创建DOM解析器，解析XML文档
			Document doc = db.parse(xmlPath); // 使用dom解析xml文件
			// 遍历列表，进行XML文件的数据提取
			// 根据节点名称来获取所有相关的节点
			NodeList sonlist = doc.getElementsByTagName("scenic");
			i = sonlist.getLength();

		} catch (Exception e) {
			System.out.println(e.getMessage());
		}
		return i;
	}
}